package com.cjet.nissan.tcp

import io.netty.channel.ChannelFuture
import io.netty.channel.ChannelHandlerContext
import java.net.SocketAddress
import java.util.Objects


interface INetty {


    /**
     * 建立连接
     *
     * @param host 主机
     * @param port 端口
     */
    fun connect(host: String?, port: Int)

    /**
     * 建立连接
     *
     * @param socketAddress 连接地址
     */
    fun connect(socketAddress: SocketAddress?)

    /**
     * 同步阻塞的方式建立连接
     *
     * @param host 主机
     * @param port 端口
     * @return 是否连接成功
     */
    fun connectBlocking(host: String?, port: Int): Boolean

    /**
     * 同步阻塞的方式建立连接
     *
     * @param socketAddress 连接地址
     * @return 是否连接成功
     */
    fun connectBlocking(socketAddress: SocketAddress?): Boolean

    /**
     * 重连
     * @param delayMillis 重连延迟毫秒数
     */
    fun reconnect(delayMillis: Long)

    /**
     * 阻塞的方式同步重连
     *
     * @return 是否重连成功
     */
    fun reconnectBlocking(): Boolean

    /**
     * 发送消息
     *
     * @param msg 消息数据
     */
    fun sendMessage(msg: Any?)

    /**
     * 阻塞的方式同步发送消息
     *
     * @param msg 消息数据
     * @return 是否发送成功
     */
    fun sendMessageBlocking(msg: Any?): Boolean

    /**
     * 设置连接监听
     *
     * @param listener [OnConnectListener]
     */
    fun setOnConnectListener(listener: OnConnectListener?)

    /**
     * 设置消息发送监听
     *
     * @param listener [OnSendMessageListener]
     */
    fun setOnSendMessageListener(listener: OnSendMessageListener?)

    /**
     * 关闭连接
     */
    fun close()

    /**
     * 同步阻塞的方式关闭连接
     * @return 是否关闭
     */
    fun closeBlocking(): Boolean

    /**
     * 断开链接
     */
    fun disconnect()

    /**
     * 同步阻塞的方式断开连接
     * @return 是否断开连接
     */
    fun disconnectBlocking(): Boolean

    /**
     * 是否连接
     *
     * @return 是否已连接
     */
    fun isConnected(): Boolean

    /**
     * 是否打开
     *
     * @return 连接通道是否打开
     */
    fun isOpen(): Boolean

    /**
     * 获取[ChannelFuture]
     *
     * @return 获取连接的 [ChannelFuture]
     */
    fun getChannelFuture(): ChannelFuture?

    /**
     * 连接监听
     */
    interface OnConnectListener {
        /**
         * 连接成功
         */
        fun onSuccess()

        /**
         * 连接失败
         *
         * @param e 异常信息
         */
        fun onFailure(e: Throwable?)
    }

    /**
     * 通道消息处理（接收消息）
     */
    interface OnChannelHandler {
        /**
         * 接收消息
         *
         * @param ctx [ChannelHandlerContext]
         * @param msg 接收到的消息
         */
        fun onMessageReceived(ctx: ChannelHandlerContext?, msg: Any?)

        /**
         * 异常
         *
         * @param ctx [ChannelHandlerContext]
         * @param e 异常信息
         */
        fun onExceptionCaught(ctx: ChannelHandlerContext?, e: Throwable?)
    }

    /**
     * 发送消息监听
     */
    interface OnSendMessageListener {
        /**
         * 发送消息
         *
         * @param msg 消息数据
         */
        fun onSendMessage(msg: Any?)

        /**
         * 异常
         *
         * @param e 异常信息
         */
        fun onException(e: Throwable?)
    }
}